home *** CD-ROM | disk | FTP | other *** search
/ BMUG Revelations / BMUG Revelations.toast / Utilities / Random / Commodore 64c / SOURCE / NewHard.c < prev    next >
C/C++ Source or Header  |  1994-03-20  |  5KB  |  259 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #include "MemoryCalls.h"
  5. #include "Serial.h"
  6. #include "Floppy.h"
  7. #include "FileTypes.h"
  8. #include <Files.h>
  9.  
  10. /*
  11.  * File system interface
  12.  */
  13.  
  14. enum fsmode {Write, Read, Directory};
  15.  
  16. struct fs_buffer_info {
  17.     short fnum;        /* FILE *fd */
  18.     FSSpec direntry;        /* DIR *dp */
  19.     enum fsmode mode;
  20.     byte    buf[70];
  21.     int     buflen;
  22.     byte   *bufp;
  23.     int     eof;
  24. }       fs_info[2];
  25.  
  26. byte write_fs(unsigned char data, int secondary)
  27. {
  28.     long len;
  29.     
  30.     if (fs_info[secondary].mode != Write) return kFloppyError;
  31.  
  32.     if (fs_info[secondary].fd==1)
  33.     {
  34.         len=1; FSWrite(fs_info[secondary].fnum, &len, &data);
  35.         if (len==1) return kSerialOK;
  36.         else return kFloppyError;
  37.     };
  38.  
  39.     return kFloppyError;
  40. }
  41.  
  42.  
  43. int     petconv(int c)
  44. {
  45.     switch (c & 0xe0)
  46.     {
  47.     case 0x40:
  48.     case 0x60:
  49.         return (c ^ 0x20);
  50.     }
  51.     return (c);
  52. }
  53.  
  54. void    petconvstring(char *c)
  55. {
  56.     int i;
  57.     for (i = strlen(c) - 1; i >= 0; i--)
  58.         c[i] = petconv(c[i]);
  59. }
  60.  
  61. byte     read_fs(unsigned char *data, int secondary)
  62. {
  63.     int i;
  64.     unsigned short blocks;
  65.     struct fs_buffer_info *info = &fs_info[secondary];
  66.     long len;
  67.     char name[256];
  68.     
  69.     switch (info -> mode)
  70.     {
  71.     case Write:
  72.         return kFloppyError;
  73.  
  74.     case Read:
  75.         if (info -> fd)
  76.         {
  77.             len=1; err=FSRead(fs_info[secondary].fnum, &len, data);
  78.             if (err==noErr) return kSerialOK;
  79.             else if (err==eofErr) return kSerialEOF;
  80.             else return kFloppyError;
  81.         }
  82.         break;
  83.  
  84.     case Directory:
  85.         if (info -> buflen <= 0)
  86.         {
  87.             myCPB.ioNamePtr=name;
  88.             myCPB.ioVRefNum=0;
  89.             myCPB.ioFDirIndex=info->index;
  90.             myCPB.ioDirID=0;
  91.             err=PBGetCatInfo(&myCPB, false);
  92.             if (err==noErr)
  93.             {
  94.                 ptr=info->buf; ch=0;
  95.                 *p++=1; ch++;
  96.                 *p++=4; ch++;
  97.                 
  98.                 blocks=myCPB.ioFlLgLen / 256L;
  99.                 *p++=blocks&256;  ch++;
  100.                 *p++=(blocks>>8)&256;  ch++;
  101.                 
  102.                 for (j = 0; blocks > 9; j++) blocks /= 10;
  103.                 i = 4 - j;
  104.                 if (i < 0) i=0;
  105.                 while (i-- > 0) { *p++ = ' ';  ch++; }
  106.                 
  107.                 *p++ = '"';  ch++;
  108.                 for (i = 0; i < name[0]; i++) { *p++ = petconv([i+1]);  ch++; }
  109.                 *p++ = '"';  ch++;
  110.                 *p++ = '\0';  ch++;
  111.  
  112.                 info -> buflen = ch;
  113.             }
  114.             else
  115.             {
  116.                 info -> buf[0] = 0;
  117.                 info -> buf[1] = 0;
  118.                 info -> buf[2] = 0;
  119.                 info -> buflen = 3;
  120.                 info -> eof++;
  121.             }
  122.             info -> bufp = info -> buf;
  123.         }
  124.         *data = *info -> bufp++;
  125.         info -> buflen--;
  126.         return kSerialOK;
  127.     }
  128.     
  129.     return kFloppyError;
  130. }
  131.  
  132.  
  133.  
  134. byte open_fs(char *name, int length, int secondary)
  135. {
  136.     FILE   *fd;
  137.     DIR    *dp;
  138.     char    tmp[256], *p;
  139.  
  140.     if (fs_info[secondary].fd) return kFloppyError;
  141.  
  142.     /*
  143.      * Support only load / save
  144.      */
  145.     if (secondary < 0 || secondary >= 2) return kFloppyError;
  146.  
  147.     memcpy(tmp, name, length);
  148.     tmp[length] = 0;
  149.     petconvstring(tmp);
  150.     
  151.     if (*tmp == '$') {
  152.     if (secondary != 0)
  153.         return kFloppyError;
  154.  
  155.     if (tmp[1]) {
  156.         if (!(dp = opendir((char *)tmp + 1))) {
  157.         for (p = tmp; *p; p++)
  158.             if (isupper(*p))
  159.             *p = tolower(*p);
  160.         if (!(dp = opendir((char *)tmp + 1)))
  161.             return kFloppyError;
  162.         }
  163.         strcpy(fs_info[secondary].dir, tmp + 1);
  164.     } else {
  165.         if (!(dp = opendir(".")))
  166.         return kFloppyError;
  167.         strcpy(fs_info[secondary].dir, ".");
  168.     }
  169.  
  170.     fs_info[secondary].mode = Directory;
  171.     fs_info[secondary].dp = dp;
  172.     fs_info[secondary].eof = 0;
  173.     fs_info[secondary].buflen = 2;
  174.     fs_info[secondary].bufp = fs_info[secondary].buf;
  175.     fs_info[secondary].buf[0] = 0;
  176.     fs_info[secondary].buf[1] = 4;
  177.  
  178.     } else {
  179.     fs_info[secondary].mode = (secondary == 1 ? Write : Read);
  180.     fd = fopen(tmp, fs_info[secondary].mode ? "r" : "w+");
  181.  
  182.     if (!fd) {
  183.         for (p = tmp; *p; p++)
  184.         if (isupper(*p))
  185.             *p = tolower(*p);
  186.  
  187.         fd = fopen(tmp, fs_info[secondary].mode ? "r" : "w+");
  188.  
  189.         if (!fd)
  190.         return kFloppyError;
  191.     }
  192.     fs_info[secondary].fd = fd;
  193.     }
  194.     return kSerialOK;
  195. }
  196.  
  197.  
  198.  
  199. byte     close_fs(int secondary)
  200. {
  201.     switch (fs_info[secondary].mode) {
  202.       case Write:
  203.       case Read:
  204.     if (!fs_info[secondary].fd)
  205.         return FLOPPY_ERROR;
  206.  
  207.     fclose(fs_info[secondary].fd);
  208.     fs_info[secondary].fd = NULL;
  209.     break;
  210.  
  211.       case Directory:
  212.     if (!fs_info[secondary].dp)
  213.         return FLOPPY_ERROR;
  214.  
  215.     closedir(fs_info[secondary].dp);
  216.     fs_info[secondary].dp = NULL;
  217.     break;
  218.     }
  219.  
  220.     return FLOPPY_COMMAND_OK;
  221. }
  222.  
  223. HFileInfo myCPB;
  224. char fname[256];
  225. short totalFiles, totalDirs;
  226.  
  227. main()
  228.  
  229. myCPB.ioNamePtr=(unsigned char *)fname;
  230. myCPB.ioVRefNum=0;
  231. EnumCatalog(fsRtDirID);
  232.  
  233.  
  234. EnumCatalog(long searchId)
  235. {
  236.     short index=1;
  237.     OSErr err;
  238.     
  239.     do
  240.     {
  241.         myCPB.ioDFirIndex=index;
  242.         myCPB.ioDirID=dirIdToSearch;
  243.         err=PBGetCatInfo(&myCPB, false);
  244.         
  245.         if (err=noErr)
  246.         {
  247.             if (((myCPB.ioFlAttrib>>4)&0x01)==1)
  248.             {
  249.                 dir
  250.             }
  251.             else
  252.             {
  253.                 print name;
  254.             }
  255.             index++;
  256.         }
  257.     } while (err!=fnfErr);
  258. }
  259.